<?php

/**
 * XML-parsing classes to wrap the domxml and DOM extensions for PHP 4
 * and 5, respectively.
 *
 * @package OpenID
 */

// Do not allow direct access
defined( '_JEXEC' ) or die( 'Restricted access' );

/**
 * The base class for wrappers for available PHP XML-parsing
 * extensions.  To work with this Yadis library, subclasses of this
 * class MUST implement the API as defined in the remarks for this
 * class.  Subclasses of Auth_Yadis_XMLParser are used to wrap
 * particular PHP XML extensions such as 'domxml'.  These are used
 * internally by the library depending on the availability of
 * supported PHP XML extensions.
 *
 * @package OpenID
 */
class Auth_Yadis_XMLParser {
	/**
	 * Initialize an instance of Auth_Yadis_XMLParser with some
	 * XML and namespaces.  This SHOULD NOT be overridden by
	 * subclasses.
	 *
	 * @param string $xml_string A string of XML to be parsed.
	 * @param array $namespace_map An array of ($ns_name => $ns_uri)
	 * to be registered with the XML parser.  May be empty.
	 * @return boolean $result True if the initialization and
	 * namespace registration(s) succeeded; false otherwise.
	 */
	function init($xml_string, $namespace_map)
	{
		if (!$this->setXML($xml_string)) {
			return false;
		}

		foreach ($namespace_map as $prefix => $uri) {
			if (!$this->registerNamespace($prefix, $uri)) {
				return false;
			}
		}

		return true;
	}

	/**
	 * Register a namespace with the XML parser.  This should be
	 * overridden by subclasses.
	 *
	 * @param string $prefix The namespace prefix to appear in XML tag
	 * names.
	 *
	 * @param string $uri The namespace URI to be used to identify the
	 * namespace in the XML.
	 *
	 * @return boolean $result True if the registration succeeded;
	 * false otherwise.
	 */
	function registerNamespace($prefix, $uri)
	{
		// Not implemented.
	}

	/**
	 * Set this parser object's XML payload.  This should be
	 * overridden by subclasses.
	 *
	 * @param string $xml_string The XML string to pass to this
	 * object's XML parser.
	 *
	 * @return boolean $result True if the initialization succeeded;
	 * false otherwise.
	 */
	function setXML($xml_string)
	{
		// Not implemented.
	}

	/**
	 * Evaluate an XPath expression and return the resulting node
	 * list.  This should be overridden by subclasses.
	 *
	 * @param string $xpath The XPath expression to be evaluated.
	 *
	 * @param mixed $node A node object resulting from a previous
	 * evalXPath call.  This node, if specified, provides the context
	 * for the evaluation of this xpath expression.
	 *
	 * @return array $node_list An array of matching opaque node
	 * objects to be used with other methods of this parser class.
	 */
	function evalXPath($xpath, $node = null)
	{
		// Not implemented.
	}

	/**
	 * Return the textual content of a specified node.
	 *
	 * @param mixed $node A node object from a previous call to
	 * $this->evalXPath().
	 *
	 * @return string $content The content of this node.
	 */
	function content($node)
	{
		// Not implemented.
	}

	/**
	 * Return the attributes of a specified node.
	 *
	 * @param mixed $node A node object from a previous call to
	 * $this->evalXPath().
	 *
	 * @return array $attrs An array mapping attribute names to
	 * values.
	 */
	function attributes($node)
	{
		// Not implemented.
	}
}

/**
 * This concrete implementation of Auth_Yadis_XMLParser implements
 * the appropriate API for the 'domxml' extension which is typically
 * packaged with PHP 4.  This class will be used whenever the 'domxml'
 * extension is detected.  See the Auth_Yadis_XMLParser class for
 * details on this class's methods.
 *
 * @package OpenID
 */
class Auth_Yadis_domxml extends Auth_Yadis_XMLParser {
	function Auth_Yadis_domxml()
	{
		$this->xml = null;
		$this->doc = null;
		$this->xpath = null;
		$this->errors = array();
	}

	function setXML($xml_string)
	{
		$this->xml = $xml_string;
		$this->doc = @domxml_open_mem($xml_string, DOMXML_LOAD_PARSING,
									  $this->errors);

		if (!$this->doc) {
			return false;
		}

		$this->xpath = $this->doc->xpath_new_context();

		return true;
	}

	function registerNamespace($prefix, $uri)
	{
		return xpath_register_ns($this->xpath, $prefix, $uri);
	}

	function &evalXPath($xpath, $node = null)
	{
		if ($node) {
			$result = @$this->xpath->xpath_eval($xpath, $node);
		} else {
			$result = @$this->xpath->xpath_eval($xpath);
		}

		if (!$result) {
			$n = array();
			return $n;
		}

		if (!$result->nodeset) {
			$n = array();
			return $n;
		}

		return $result->nodeset;
	}

	function content($node)
	{
		if ($node) {
			return $node->get_content();
		}
	}

	function attributes($node)
	{
		if ($node) {
			$arr = $node->attributes();
			$result = array();

			if ($arr) {
				foreach ($arr as $attrnode) {
					$result[$attrnode->name] = $attrnode->value;
				}
			}

			return $result;
		}
	}
}

/**
 * This concrete implementation of Auth_Yadis_XMLParser implements
 * the appropriate API for the 'dom' extension which is typically
 * packaged with PHP 5.  This class will be used whenever the 'dom'
 * extension is detected.  See the Auth_Yadis_XMLParser class for
 * details on this class's methods.
 *
 * @package OpenID
 */
class Auth_Yadis_dom extends Auth_Yadis_XMLParser {
	function Auth_Yadis_dom()
	{
		$this->xml = null;
		$this->doc = null;
		$this->xpath = null;
		$this->errors = array();
	}

	function setXML($xml_string)
	{
		$this->xml = $xml_string;
		$this->doc = new DOMDocument;

		if (!$this->doc) {
			return false;
		}

		if (!@$this->doc->loadXML($xml_string)) {
			return false;
		}

		$this->xpath = new DOMXPath($this->doc);

		if ($this->xpath) {
			return true;
		} else {
			return false;
		}
	}

	function registerNamespace($prefix, $uri)
	{
		return $this->xpath->registerNamespace($prefix, $uri);
	}

	function &evalXPath($xpath, $node = null)
	{
		if ($node) {
			$result = @$this->xpath->query($xpath, $node);
		} else {
			$result = @$this->xpath->query($xpath);
		}

		$n = array();

		if (!$result) {
			return $n;
		}

		for ($i = 0; $i < $result->length; $i++) {
			$n[] = $result->item($i);
		}

		return $n;
	}

	function content($node)
	{
		if ($node) {
			return $node->textContent;
		}
	}

	function attributes($node)
	{
		if ($node) {
			$arr = $node->attributes;
			$result = array();

			if ($arr) {
				for ($i = 0; $i < $arr->length; $i++) {
					$node = $arr->item($i);
					$result[$node->nodeName] = $node->nodeValue;
				}
			}

			return $result;
		}
	}
}

global $__Auth_Yadis_defaultParser;
$__Auth_Yadis_defaultParser = null;

/**
 * Set a default parser to override the extension-driven selection of
 * available parser classes.  This is helpful in a test environment or
 * one in which multiple parsers can be used but one is more
 * desirable.
 *
 * @param Auth_Yadis_XMLParser $parser An instance of a
 * Auth_Yadis_XMLParser subclass.
 */
function Auth_Yadis_setDefaultParser(&$parser)
{
	global $__Auth_Yadis_defaultParser;
	$__Auth_Yadis_defaultParser =& $parser;
}

function Auth_Yadis_getSupportedExtensions()
{
	return array(
				 'dom' => array('classname' => 'Auth_Yadis_dom',
					   'libname' => array('dom.so', 'dom.dll')),
				 'domxml' => array('classname' => 'Auth_Yadis_domxml',
					   'libname' => array('domxml.so', 'php_domxml.dll')),
				 );
}

/**
 * Returns an instance of a Auth_Yadis_XMLParser subclass based on
 * the availability of PHP extensions for XML parsing.  If
 * Auth_Yadis_setDefaultParser has been called, the parser used in
 * that call will be returned instead.
 */
function &Auth_Yadis_getXMLParser()
{
	global $__Auth_Yadis_defaultParser;

	if (isset($__Auth_Yadis_defaultParser)) {
		return $__Auth_Yadis_defaultParser;
	}

	$p = null;
	$classname = null;

	$extensions = Auth_Yadis_getSupportedExtensions();

	// Return a wrapper for the resident implementation, if any.
	foreach ($extensions as $name => $params) {
		if (!extension_loaded($name)) {
			foreach ($params['libname'] as $libname) {
				if (@dl($libname)) {
					$classname = $params['classname'];
				}
			}
		} else {
			$classname = $params['classname'];
		}
		if (isset($classname)) {
			$p = new $classname();
			return $p;
		}
	}

	if (!isset($p)) {
		trigger_error('No XML parser was found', E_USER_ERROR);
	} else {
		Auth_Yadis_setDefaultParser($p);
	}

	return $p;
}

?>
